#pragma once

#include "strategy/strategy.h"
#include "utils/memory_pool.h"
#include "utils/optimized_price_history.h"
#include "utils/optimized_spread_history.h"
#include "utils/simd_math.h"
#include "utils/simd_math_ext.h"
#include <string>
#include <memory>
#include <unordered_map>
#include <vector>
#include <atomic>
#include <mutex>

namespace hft {

/**
 * @brief 优化的策略基类
 * 
 * 这个类为所有优化的策略提供基础功能，包括：
 * - 内存池管理
 * - 优化的价格历史管理
 * - SIMD优化的数学运算
 * - 线程安全的数据访问
 */
class OptimizedStrategyBase : public Strategy {
public:
    /**
     * @brief 构造函数
     * @param name 策略名称
     */
    explicit OptimizedStrategyBase(const std::string& name)
        : Strategy(name)
        , price_histories_(std::make_shared<OptimizedMultiPriceHistory>(1000))
        , spread_histories_(std::make_shared<OptimizedMultiSpreadHistory>(1000))
        , market_data_pool_(1000)
        , order_pool_(100)
        , is_running_(false) {
        
        // 检测SIMD支持级别
        simd_level_ = utils::simd::getSimdLevel();
        LOG(INFO) << "创建优化策略: " << name << ", SIMD支持级别: " << getSimdLevelString();
    }
    
    /**
     * @brief 析构函数
     */
    virtual ~OptimizedStrategyBase() {
        stop();
    }
    
    /**
     * @brief 启动策略
     */
    void start() override {
        is_running_ = true;
        LOG(INFO) << "启动优化策略: " << getName();
    }
    
    /**
     * @brief 停止策略
     */
    void stop() override {
        is_running_ = false;
        LOG(INFO) << "停止优化策略: " << getName();
    }
    
    /**
     * @brief 处理市场数据
     * @param data 市场数据
     */
    void onMarketData(const MarketData& data) override {
        if (!is_running_) return;
        
        // 使用对象池分配MarketData对象的副本
        auto* data_copy = market_data_pool_.create(data);
        
        try {
            // 更新价格历史
            price_histories_->addPrice(data.symbol, data.close);
            
            // 子类处理逻辑
            processMarketData(*data_copy);
            
        } catch (const std::exception& e) {
            LOG(ERROR) << "处理市场数据时发生错误: " << e.what();
        }
        
        // 释放市场数据对象
        market_data_pool_.destroy(data_copy);
    }
    
    /**
     * @brief 处理订单更新
     * @param order 订单
     */
    void onOrderUpdate(const Order& order) override {
        if (!is_running_) return;
        
        // 使用对象池分配Order对象的副本
        auto* order_copy = order_pool_.create(order);
        
        try {
            // 子类处理逻辑
            processOrderUpdate(*order_copy);
            
        } catch (const std::exception& e) {
            LOG(ERROR) << "处理订单更新时发生错误: " << e.what();
        }
        
        // 释放订单对象
        order_pool_.destroy(order_copy);
    }
    
    /**
     * @brief 获取策略状态
     * @return 策略状态的JSON字符串
     */
    std::string getState() const override {
        nlohmann::json state;
        state["name"] = getName();
        state["is_running"] = is_running_;
        state["simd_level"] = getSimdLevelString();
        
        // 添加内存池统计信息
        auto [market_data_allocated, market_data_freed] = market_data_pool_.getStats();
        auto [order_allocated, order_freed] = order_pool_.getStats();
        
        state["memory_pool"] = {
            {"market_data_allocated", market_data_allocated},
            {"market_data_freed", market_data_freed},
            {"market_data_active", market_data_allocated - market_data_freed},
            {"order_allocated", order_allocated},
            {"order_freed", order_freed},
            {"order_active", order_allocated - order_freed},
            {"market_data_blocks", market_data_pool_.getBlockCount()},
            {"order_blocks", order_pool_.getBlockCount()}
        };
        
        return state.dump(4);
    }
    
    /**
     * @brief 清理未使用的内存
     */
    void shrinkMemoryPools() {
        market_data_pool_.shrink();
        order_pool_.shrink();
        LOG(INFO) << "清理未使用的内存池: " << getName();
    }
    
protected:
    /**
     * @brief 子类处理市场数据的方法
     * @param data 市场数据
     */
    virtual void processMarketData(const MarketData& data) {
        // 子类实现
    }
    
    /**
     * @brief 子类处理订单更新的方法
     * @param order 订单
     */
    virtual void processOrderUpdate(const Order& order) {
        // 子类实现
    }
    
    /**
     * @brief 获取价格历史管理器
     * @return 价格历史管理器
     */
    std::shared_ptr<OptimizedMultiPriceHistory> getPriceHistories() const {
        return price_histories_;
    }
    
    /**
     * @brief 获取价差历史管理器
     * @return 价差历史管理器
     */
    std::shared_ptr<OptimizedMultiSpreadHistory> getSpreadHistories() const {
        return spread_histories_;
    }
    
    /**
     * @brief 获取特定品种的价格历史
     * @param symbol 交易品种
     * @return 价格历史指针
     */
    std::shared_ptr<OptimizedPriceHistory> getPriceHistory(const std::string& symbol) const {
        return price_histories_->getPriceHistory(symbol);
    }
    
    /**
     * @brief 获取特定对的价差历史
     * @param symbol1 第一个交易品种
     * @param symbol2 第二个交易品种
     * @return 价差历史指针
     */
    std::shared_ptr<OptimizedSpreadHistory> getSpreadHistory(const std::string& symbol1, const std::string& symbol2) const {
        return spread_histories_->getSpreadHistory(symbol1, symbol2);
    }
    
    /**
     * @brief 获取SIMD支持级别的字符串表示
     * @return SIMD支持级别字符串
     */
    std::string getSimdLevelString() const {
        switch (simd_level_) {
            case utils::simd::SimdLevel::AVX: return "AVX";
            case utils::simd::SimdLevel::SSE4_1: return "SSE4.1";
            case utils::simd::SimdLevel::SSE3: return "SSE3";
            case utils::simd::SimdLevel::SSE2: return "SSE2";
            default: return "None";
        }
    }
    
    /**
     * @brief 创建订单
     * @param symbol 交易品种
     * @param direction 方向
     * @param type 订单类型
     * @param quantity 数量
     * @param price 价格（限价单）
     * @return 订单指针
     */
    Order* createOrder(const std::string& symbol, OrderDirection direction, 
                      OrderType type, double quantity, double price = 0.0) {
        Order* order = order_pool_.create();
        order->symbol = symbol;
        order->direction = direction;
        order->type = type;
        order->quantity = quantity;
        order->price = price;
        order->status = OrderStatus::PENDING;
        return order;
    }
    
    /**
     * @brief 释放订单
     * @param order 订单指针
     */
    void releaseOrder(Order* order) {
        if (order) {
            order_pool_.destroy(order);
        }
    }
    
    /**
     * @brief 发送订单
     * @param symbol 交易品种
     * @param direction 方向
     * @param type 订单类型
     * @param quantity 数量
     * @param price 价格（限价单）
     */
    void sendOrder(const std::string& symbol, OrderDirection direction, 
                  OrderType type, double quantity, double price = 0.0) {
        Order* order = createOrder(symbol, direction, type, quantity, price);
        if (trading_system_) {
            trading_system_->processOrder(*order);
        }
        releaseOrder(order);
    }
    
private:
    std::shared_ptr<OptimizedMultiPriceHistory> price_histories_;   // 价格历史管理器
    std::shared_ptr<OptimizedMultiSpreadHistory> spread_histories_; // 价差历史管理器
    utils::MemoryPool<MarketData> market_data_pool_;               // 市场数据对象池
    utils::MemoryPool<Order> order_pool_;                          // 订单对象池
    std::atomic<bool> is_running_;                                 // 是否正在运行
    utils::simd::SimdLevel simd_level_;                            // SIMD支持级别
};

} // namespace hft